home *** CD-ROM | disk | FTP | other *** search
/ Inter.Net 55-1 / Inter.Net 55-1.iso / CBuilder / Setup / BCB / data.z / fstream.cc < prev    next >
Encoding:
C/C++ Source or Header  |  1998-02-09  |  31.3 KB  |  1,420 lines
  1. #ifndef __FSTREAM_CC
  2. #define __FSTREAM_CC
  3. #pragma option push -b -a4 -Vx- -Ve- -w-inl -w-aus -w-sig
  4.  
  5. /***************************************************************************
  6.  *
  7.  * fstream.cc - Definition for the Standard Library file streams
  8.  *
  9.  * $Id: fstream.cc,v 1.79 1996/09/27 07:04:46 philippe Exp $
  10.  *
  11.  ***************************************************************************
  12.  *
  13.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  14.  * ALL RIGHTS RESERVED *
  15.  * The software and information contained herein are proprietary to, and
  16.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  17.  * intends to preserve as trade secrets such software and information.
  18.  * This software is furnished pursuant to a written license agreement and
  19.  * may be used, copied, transmitted, and stored only in accordance with
  20.  * the terms of such license and with the inclusion of the above copyright
  21.  * notice.  This software and information or any other copies thereof may
  22.  * not be provided or otherwise made available to any other person.
  23.  *
  24.  * Notwithstanding any other lease or license that may pertain to, or
  25.  * accompany the delivery of, this computer software and information, the
  26.  * rights of the Government regarding its use, reproduction and disclosure
  27.  * are as set forth in Section 52.227-19 of the FARS Computer
  28.  * Software-Restricted Rights clause.
  29.  * 
  30.  * Use, duplication, or disclosure by the Government is subject to
  31.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  32.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  33.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  34.  * P.O. Box 2328, Corvallis, Oregon 97339.
  35.  *
  36.  * This computer software and information is distributed with "restricted
  37.  * rights."  Use, duplication or disclosure is subject to restrictions as
  38.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  39.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  40.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  41.  * then the "Alternate III" clause applies.
  42.  *
  43.  **************************************************************************/
  44.  
  45. #ifndef _RWSTD_NO_NEW_HEADER
  46. #include <cstdio>
  47. #else
  48. #include <stdio.h>
  49. #endif
  50.  
  51.  
  52. #ifndef _RWSTD_NO_NAMESPACE
  53. namespace std {
  54. #endif
  55.  
  56. //
  57. // Work-around for Borland problem.
  58. //
  59. #ifdef __BORLANDC__
  60. template <class T>
  61. void __io_initialize (T& t, T val) { t = val; }
  62. #endif
  63.  
  64. /*
  65.  *
  66.  *
  67.  * class basic_filebuf
  68.  *
  69.  *
  70.  */
  71.  
  72. /*
  73.  * basic_filebuf()
  74.  */
  75.  
  76. template<class charT, class traits>
  77. basic_filebuf<charT, traits>::basic_filebuf()
  78. : basic_streambuf<charT, traits>()
  79. , file_(-1)
  80. , data_(0)
  81. , read_buff_(false)
  82. , write_buff_(false)
  83. , last_numb_read_(0)
  84. , __rwBufferSize(512)
  85. , absolute_pos(0)
  86. {
  87.   state_beg = new state_t;
  88.   state_end = new state_t;
  89. }
  90.  
  91. /*
  92.  * basic_filebuf(int)
  93.  */
  94.  
  95. template<class charT, class traits>
  96. basic_filebuf<charT, traits>::basic_filebuf(int fd)
  97. : basic_streambuf<charT, traits>()
  98. , file_(fd)
  99. , read_buff_(false)
  100. , write_buff_(false)
  101. , last_numb_read_(0)
  102. , __rwBufferSize(512)
  103. , absolute_pos(0)
  104. {
  105.   data_ = new char_type[__rwBufferSize+1];
  106.   state_beg = new state_t;
  107.   state_end = new state_t;
  108.  
  109.   if ( fd == 0 )
  110.    basic_streambuf<charT,traits>::mode_ = ios_base::in;
  111.   else
  112.   {
  113.     if ( fd < 3 )
  114.      basic_streambuf<charT,traits>::mode_ = ios_base::out;
  115.   }
  116.  
  117. }
  118.  
  119.  
  120. /*
  121.  * ~basic_filebuf()
  122.  */
  123.  
  124. template<class charT, class traits>
  125. basic_filebuf<charT, traits>::~basic_filebuf()
  126. {
  127.   close();
  128.   delete state_beg;
  129.   delete state_end;
  130. }
  131.  
  132. /*
  133.  * bool is_open() const
  134.  */
  135.  
  136. template<class charT, class traits>
  137. bool basic_filebuf<charT, traits>::is_open() const
  138. {
  139.   return !(file_ == -1);
  140. }
  141.  
  142. /*
  143.  * basic_filebuf *open(int fd)
  144.  *
  145.  * fstream compatibility
  146.  */
  147.  
  148.  
  149. template<class charT, class traits>
  150. basic_filebuf<charT, traits> *
  151. basic_filebuf<charT, traits>::
  152. open(int fd )
  153. {   
  154.   if(file_ != -1)
  155.      return 0;
  156.  
  157.   this->streambuf_init(false); 
  158.  
  159.   file_           = fd;
  160.   read_buff_      = false;
  161.   write_buff_     = false;
  162.   last_numb_read_ = 0; 
  163.  
  164.   delete [] data_;
  165.  
  166.   data_ = new char_type[__rwBufferSize+1];
  167.  
  168.   if ( fd == 0 )
  169.    basic_streambuf<charT,traits>::mode_ = ios_base::in;
  170.   else
  171.   {
  172.     if ( fd < 3 )
  173.      basic_streambuf<charT,traits>::mode_ = ios_base::out;
  174.   }
  175.  
  176.   return this;
  177. }
  178.  
  179.  
  180.  
  181. /*
  182.  * basic_filebuf *open(const char *, ios_base::openmode, long )
  183.  *
  184.  * opens a file and allocates a buffer
  185.  */
  186.  
  187.  
  188. template<class charT, class traits>
  189. basic_filebuf<charT, traits> *
  190. basic_filebuf<charT, traits>::
  191. open(const char *s, ios_base::openmode mode, long protection)
  192. {
  193.   #if !defined(_RWSTD_NO_NAMESPACE) && !defined(_RWSTD_NO_NEW_HEADER)
  194.   using std::open;
  195.   #endif
  196.  
  197.   long    m;
  198.  
  199.   if ( mode & ios_base::ate )
  200.    m = (mode & (~ios_base::ate)) | ios_base::app;
  201.   else
  202.    m = mode;
  203.   
  204.   if(file_ != -1)
  205.      return 0;
  206.  
  207.   basic_streambuf<charT,traits>::mode_ = mode;
  208.  
  209.   this->streambuf_init(false);
  210.  
  211.   if(__rwOpenTable[m] == -1) 
  212.    return 0;
  213.  
  214.  #if !defined(_RWSTD_NO_NAMESPACE) && !defined(_RWSTD_NO_NEW_HEADER)
  215.    if((file_ = open(s, __rwOpenTable[m], protection)) == -1)
  216.  #else
  217.    if((file_ = ::open(s, __rwOpenTable[m], protection)) == -1)
  218.  #endif
  219.    return 0;
  220.  
  221.   delete [] data_;
  222.  
  223.   data_ = new char_type[__rwBufferSize+1];
  224.  
  225.   if(mode & ios_base::ate) {
  226.      if( (absolute_pos = lseek(file_, 0, SEEK_END))== -1  ) {
  227.         close();
  228.         delete [] data_;  
  229.         data_ = 0;
  230.                 file_=-1;
  231.         return 0;
  232.      }
  233.   }
  234.  
  235.     
  236.   return this;
  237. }
  238.  
  239. /*
  240.  * basic_filebuf *close()
  241.  *
  242.  * closes a file if one was already open.  Also deletes the
  243.  * data, if it was allocated
  244.  */
  245.  
  246. template<class charT, class traits>
  247. basic_filebuf<charT, traits> *
  248. basic_filebuf<charT, traits>::close()
  249. {
  250.   #if !defined(_RWSTD_NO_NAMESPACE) && !defined(_RWSTD_NO_NEW_HEADER)
  251.   using std::close;
  252.   #endif
  253.  
  254. delete state_beg;
  255. delete state_end;
  256. state_beg = new state_t;
  257. state_end = new state_t;
  258.  
  259. absolute_pos = 0;
  260.  
  261. if ( (file_ < 3)  && (file_ != -1) )
  262.  {
  263.     if ( write_buff_ )
  264.      overflow( traits::eof() );
  265.     read_buff_=false;
  266.     write_buff_=false;
  267.     last_numb_read_=0;
  268.     return this;
  269.  }
  270.    
  271.   if(file_ != -1) {          
  272.     if ( write_buff_ )
  273.      overflow( traits::eof() );
  274.     delete [] data_;
  275.     data_ = 0;
  276.     read_buff_=false;
  277.     write_buff_=false;
  278.     last_numb_read_=0;
  279.  
  280.   #if !defined(_RWSTD_NO_NAMESPACE) && !defined(_RWSTD_NO_NEW_HEADER)
  281.     if(close(file_) == -1)
  282.   #else
  283.     if(::close(file_) == -1)
  284.   #endif
  285.       return 0;
  286.  
  287.     file_ = -1;
  288.  
  289.     return this;
  290.   }
  291.  
  292.   return 0;          
  293. }
  294.  
  295. /*
  296.  * int showmanyc()
  297.  */
  298.  
  299. template<class charT, class traits>
  300. int
  301. basic_filebuf<charT, traits>::showmanyc()
  302. { 
  303.    if ( gptr() )
  304.     return (int)(egptr()-gptr());
  305.    
  306.    if ( pptr() && read_buff_ )
  307.         return (int)(epptr()-pptr());   
  308.  
  309.    return 0;
  310.  
  311. }
  312.  
  313.  
  314.  
  315. /*
  316.  * int_type overflow(int_type)
  317.  *
  318.  * this is called when the put pointer overruns the buffer.
  319.  * it should flush what was in the put buffer, and move the pointer
  320.  * back to the beginning
  321.  */
  322.  
  323. template<class charT, class traits>
  324. _TYPENAME basic_filebuf<charT, traits>::int_type
  325. basic_filebuf<charT, traits>::overflow(int_type c)
  326. {
  327.   long  count = pptr() - pbase();
  328.   bool   do_noconv;
  329.  
  330.   if(file_ == -1)        
  331.    return traits::eof();
  332.  
  333.   if ( (pptr()==0) && gptr() )
  334.    {
  335.       setp(eback(),eback()+__rwBufferSize);
  336.       pbump((int)(gptr()-eback()));
  337.       setg(0,0,0);
  338.       if ( pptr()<epptr() )
  339.        { 
  340.          if( !traits::eq_int_type(c,traits::eof()) ) 
  341.           {
  342.        sputc( traits::to_char_type(c) );
  343.        this->gbump(1);
  344.            write_buff_=true;
  345.            return traits::to_int_type(*pptr());
  346.          }
  347.        } 
  348.       count=  pptr() - pbase();
  349.    }
  350.  
  351.   if ( (pptr()==0) && (gptr()==0) )
  352.     setp(data_,data_+ __rwBufferSize);  
  353.  
  354.   write_buff_= false;
  355.  
  356.   if(count)
  357.    {        
  358.     #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  359.      do_noconv = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  360.     #else
  361.      do_noconv = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  362.     #endif
  363.       .always_noconv();
  364.  
  365.     if ( do_noconv )
  366.      {
  367.         if ( read_buff_ ) 
  368.          {
  369.            if ( lseek(file_, -last_numb_read_, SEEK_CUR) == -1 )
  370.             return traits::eof();
  371.          }
  372.         if((size_t)write(file_,(char *)pbase(), count*sizeof(charT))!= 
  373.                  count*sizeof(charT))
  374.          return traits::eof();
  375.      }
  376.     else
  377.      {
  378.       long size_to = count*sizeof(charT);
  379.       const charT *from_next =0;
  380.       char *to= new char[size_to];
  381.       char *to_next = 0;
  382.       codecvt_base::result conv_result;
  383.  
  384.       if ( read_buff_ )
  385.        {
  386.          if ( lseek(file_, -last_numb_read_, SEEK_CUR) == -1 )
  387.           return traits::eof();
  388.          else
  389.           {
  390.             state_t *tmp = state_beg;
  391.             state_beg = state_end;
  392.             state_end = tmp;
  393.           }
  394.        }
  395.  
  396.        *state_beg = *state_end;
  397.  
  398.     do {
  399.  
  400.        #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  401.         conv_result = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  402.        #else
  403.         conv_result = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  404.        #endif
  405.         .out(*state_end,pbase(),pptr(),from_next,
  406.                  to,to+size_to,to_next); 
  407.  
  408.       if ( conv_result == codecvt_base::noconv ) break;
  409.  
  410.       if (  (conv_result == codecvt_base::partial) || ( from_next != pptr() ) )
  411.        {
  412.          size_to *= 2;
  413.          char *to_bis = new char[size_to];
  414.          long diff_to = to_next - to;
  415.          memcpy(to_bis,to,diff_to);
  416.          delete [] to;
  417.          to = to_bis;
  418.          to_next = to + diff_to;
  419.        }
  420.  
  421.       }while( (conv_result == codecvt_base::partial) || ( from_next != pptr()));
  422.  
  423.      if ( conv_result==codecvt_base::error )
  424.       {
  425.          delete [] to;
  426.          return traits::eof();
  427.       }
  428.  
  429.      if (conv_result == codecvt_base::noconv) 
  430.       {
  431.        if((size_t)write(file_, (char*)pbase(), sizeof(charT)*count)
  432.           != sizeof(charT) * count)
  433.          {
  434.           delete [] to;
  435.           return traits::eof();              
  436.          }
  437.       } 
  438.      else 
  439.       {
  440.        if(write(file_, to, (to_next-to)) != (to_next-to))
  441.         {
  442.           delete [] to;
  443.           return traits::eof();                
  444.         }
  445.        }
  446.  
  447.       delete [] to;
  448.     }
  449.                 
  450.   }
  451.  
  452.   setp(data_, data_+__rwBufferSize);    
  453.   setg(0,0,0);               
  454.   read_buff_ = false;        
  455.   write_buff_= false; 
  456.  
  457.   absolute_pos = lseek(file_,0,SEEK_CUR);
  458.  
  459.   if( !traits::eq_int_type(c,traits::eof()) ) 
  460.    {
  461.      sputc(traits::to_char_type(c));
  462.      this->gbump(1);
  463.      write_buff_ = true;
  464.    }
  465.   else
  466.    setp(0,0);
  467.  
  468.   return traits::not_eof(c);
  469. }
  470.  
  471. /*
  472.  * int_type pbackfail(int_type)
  473.  */
  474.  
  475.  
  476. template<class charT, class traits>
  477. _TYPENAME basic_filebuf<charT, traits>::int_type
  478. basic_filebuf<charT, traits>::pbackfail(int_type c)
  479. {
  480.   if(file_ == -1)
  481.      return traits::eof();
  482.  
  483.   if ( (gptr()==0) && pptr() )
  484.    {
  485.       if ( read_buff_ )
  486.        setg(pbase(),pptr(),epptr());
  487.       else
  488.        setg(pbase(),pptr(),pptr()); 
  489.    }
  490.  
  491.   if ( (!traits::eq_int_type(c,traits::eof())) && (gptr()>eback()) )  {
  492.  
  493.                          if ( traits::eq(*(gptr()-1),traits::to_char_type(c)) ) 
  494.                                  {
  495.                                    this->gbump(-1);
  496.                                    return c;
  497.                                  }
  498.                                 else
  499.                                  {
  500.                                    if( basic_streambuf<charT,traits>::mode_ & ios_base::out )
  501.                                      {
  502.                                        this->gbump(-1);
  503.                                        *gptr()=traits::to_char_type(c);
  504.                                        return c;
  505.                                      }
  506.                                  }
  507.                  }    
  508.  
  509.   if ( (traits::eq_int_type(c,traits::eof())) && (gptr()>eback()) )  
  510.    { 
  511.      this->gbump(-1);
  512.      return traits::not_eof(c);
  513.    }
  514.                                                 
  515.   return traits::eof();
  516.  }
  517.  
  518. /*
  519.  * basic_streambuf<charT,traits>* setbuf(char_type*,streamsize)
  520.  */
  521.  
  522. template<class charT, class traits>
  523. basic_streambuf<charT, traits>*
  524. basic_filebuf<charT, traits>::setbuf(char_type *s, streamsize n)
  525. {
  526.  
  527.  if (n>0)
  528.  { 
  529.  
  530.   if ( file_ != -1 )
  531.    {
  532.      if ( !traits::eq_int_type(overflow( traits::eof() ),traits::eof()) )
  533.        {
  534.           if ( s )
  535.            { 
  536.               delete [] data_;
  537.               __rwBufferSize = n-1; 
  538.               data_=s;
  539.            }
  540.           else
  541.            {
  542.               charT *tmp;
  543.               __rwBufferSize = n;  
  544.               tmp = new char_type[__rwBufferSize+1];
  545.               delete [] data_;
  546.               data_ = tmp;
  547.            }
  548.  
  549.           setp(0,0);    
  550.           setg(0,0,0);                         
  551.           read_buff_=false;
  552.           write_buff_=false;
  553.        }
  554.    }
  555.   else
  556.     {
  557.       if ( s )
  558.        {
  559.           __rwBufferSize = n-1;
  560.           data_ =s;
  561.           setp(0,0);    
  562.           setg(0,0,0);                        
  563.           write_buff_= false;
  564.           read_buff_ = false; 
  565.        }
  566.       else
  567.       __rwBufferSize = n;
  568.     }  
  569.  } 
  570.   return (basic_streambuf<charT,traits>*)(this); 
  571.   
  572. }
  573.  
  574.  
  575. /*
  576.  * int_type underflow()
  577.  *
  578.  * this is called when the get pointer "underflows" the buffer,
  579.  * or when there are no more "get" characters.
  580.  */
  581.  
  582. template<class charT, class traits>
  583. _TYPENAME basic_filebuf<charT, traits>::int_type
  584. basic_filebuf<charT, traits>::underflow()
  585. {
  586.   bool do_noconv;
  587.   long offset;
  588. #ifndef __BORLANDC__
  589.   offset = 0;
  590. #else
  591.   __io_initialize(offset,0L);
  592. #endif
  593.  
  594.   if(file_ == -1)
  595.     return traits::eof();
  596.  
  597.  
  598.   if ( (gptr()==0) && pptr() )
  599.    {
  600.       if ( read_buff_ )
  601.        setg(pbase(),pptr(),epptr());
  602.       else
  603.        setg(pbase(),pptr(),pptr());
  604.  
  605.       setp(0,0);
  606.    }
  607.  
  608.   if(gptr() && (gptr()<egptr()) ) return traits::to_int_type(*gptr());     
  609.  
  610.   if( ((write_buff_) && gptr() ) || ((write_buff_) && pptr() ) )
  611.     {
  612.          if ( traits::eq_int_type(overflow( traits::eof() ),traits::eof()) ) 
  613.            return traits::eof();
  614.          setg(pbase(),pptr(),epptr());
  615.          setp(0,0);
  616.          write_buff_ = false; 
  617.     }                 
  618.  
  619.     absolute_pos = lseek(file_,0,SEEK_CUR);
  620.  
  621.     #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  622.       do_noconv = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  623.     #else
  624.       do_noconv = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  625.     #endif
  626.       .always_noconv();
  627.  
  628.     if ( do_noconv )
  629.      {
  630.       last_numb_read_ = read(file_, (char *)data_,__rwBufferSize*sizeof(charT));
  631.  
  632.       if( last_numb_read_ <= 0 ) 
  633.        { 
  634.          if ( write_buff_ ) overflow( traits::eof() );
  635.          write_buff_ = false;
  636.      setp(0,0);       
  637.          setg(0,0,0);
  638.          read_buff_=false;
  639.      return traits::eof();
  640.        }
  641.       else
  642.        offset = last_numb_read_/sizeof(charT);
  643.  
  644.      }
  645.     else
  646.      {
  647.       long from_size = __rwBufferSize*sizeof(charT);
  648.       const char *from_next =0;
  649.       char *from= new char[from_size];
  650.       charT *to_next = 0;
  651.       codecvt_base::result conv_result;
  652.  
  653.       last_numb_read_ = 0;
  654.       long new_numb_read;
  655.  
  656.  
  657.       do {
  658.            new_numb_read = read(file_, from+last_numb_read_
  659.                                 ,__rwBufferSize*sizeof(charT));
  660.  
  661.            last_numb_read_ += new_numb_read;
  662.  
  663.         if( last_numb_read_ <= 0 ) 
  664.             { 
  665.              if ( write_buff_ ) overflow( traits::eof() );
  666.              write_buff_ = false;
  667.          setp(0,0);       
  668.              setg(0,0,0);
  669.              read_buff_=false;
  670.          return traits::eof();
  671.            }
  672.  
  673.          if( new_numb_read <= 0 ) 
  674.           break;
  675.  
  676.        *state_beg = *state_end;
  677.  
  678.        #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  679.         conv_result = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  680.        #else
  681.         conv_result = use_facet(this->getloc(), (codecvt<charT,char,state_t>* )0)
  682.        #endif
  683.         .in(*state_end,from,from+last_numb_read_,from_next,data_,
  684.             data_+__rwBufferSize,to_next); 
  685.  
  686.          if ( (conv_result == codecvt_base::error) ||
  687.               (conv_result == codecvt_base::noconv) ) break;
  688.  
  689.          if (  (to_next != (data_ + __rwBufferSize) ) &&
  690.                 ( (size_t)new_numb_read == __rwBufferSize*sizeof(charT) ) )
  691.            {
  692.              from_size *= 2;
  693.              char *from_bis = new char[from_size];
  694.              long diff_from = from_next - from;
  695.              memcpy(from_bis,from,last_numb_read_);
  696.              delete [] from;
  697.              from = from_bis;
  698.              from_next = from + diff_from;
  699.            }
  700.  
  701.           } while ( (to_next != (data_ + __rwBufferSize) ) &&
  702.                     ( (size_t)new_numb_read == __rwBufferSize*sizeof(charT) ) ); 
  703.                
  704.        if ( (conv_result==codecvt_base::error) ||
  705.             (conv_result==codecvt_base::partial) )
  706.        {
  707.          delete [] from;
  708.          return traits::eof();
  709.        } 
  710.       else 
  711.        {
  712.          if (conv_result==codecvt_base::noconv)
  713.           {
  714.             memcpy((char*)data_,from,last_numb_read_);
  715.             offset = last_numb_read_;
  716.           }
  717.          else
  718.             {
  719.                long diff_minus = last_numb_read_ - (from_next - from);
  720.                if ( lseek(file_, -diff_minus, SEEK_CUR) == -1 )
  721.                 return traits::eof();
  722.                last_numb_read_ -= diff_minus;
  723.                offset = to_next - data_;
  724.             }
  725.         }
  726.  
  727.       delete [] from;
  728.     }
  729.         
  730.   if(last_numb_read_) 
  731.    {   
  732.      setg(data_, data_, data_+offset); 
  733.      setp(0, 0);
  734.      read_buff_=true;
  735.      return traits::to_int_type(*gptr());
  736.    }
  737.  
  738.   return traits::eof();
  739. }
  740.  
  741. /*
  742.  * pos_type seekoff(off_type, ios_base::seekdir, ios_base::openmode)
  743.  */
  744.  
  745. template<class charT, class traits>
  746. _TYPENAME basic_filebuf<charT, traits>::pos_type
  747. basic_filebuf<charT, traits>::seekoff(off_type off,
  748.                                       ios_base::seekdir way,ios_base::openmode)
  749. {
  750.   off_type            loff = off;
  751.   pos_type            newoff;
  752.  
  753.   if(file_ == -1)
  754.     return pos_type(off_type(-1));
  755.  
  756.   if ( (off == off_type(-1)) && (way==ios_base::beg) )
  757.     return pos_type(off_type(-1));
  758.  
  759.   if ( (way==ios_base::cur) && (off==off_type(0)) )
  760.   {
  761.      streamsize remain_in_buffer=0;
  762.      
  763.      if ( read_buff_ )
  764.       {
  765.         if ( gptr() )  
  766.           remain_in_buffer= egptr()-gptr();
  767.         else
  768.          {
  769.            if ( pptr() )  remain_in_buffer= epptr()-pptr();
  770.          }
  771.       }
  772.      else
  773.       if ( write_buff_ )
  774.         {
  775.           if ( pptr() )  
  776.            remain_in_buffer= -(pptr()-pbase());
  777.           else
  778.           { 
  779.            if ( gptr() )  remain_in_buffer= -(gptr()-eback());
  780.           }
  781.         }     
  782.  
  783.     int const_conv;
  784.  
  785.     #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  786.       const_conv = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  787.     #else
  788.       const_conv = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  789.     #endif
  790.       .encoding(); 
  791.  
  792.   if ( const_conv > 0 )
  793.    {
  794.     return ( (lseek(file_,0,SEEK_CUR)-remain_in_buffer*const_conv)/const_conv);
  795.    }
  796.   else
  797.    {  
  798.       streamsize relative_pos = gptr() - eback() + pptr() - pbase();
  799.  
  800.       pos_type position(relative_pos,absolute_pos,*state_beg); 
  801.       return position;       
  802.    }
  803.   } 
  804.  
  805.    if ( way==ios_base::cur )
  806.   {
  807.      int remain_in_buffer=0;
  808.  
  809.      if ( ((read_buff_) && !(write_buff_)) ||  ((read_buff_) && (write_buff_)) )
  810.       {
  811.         if ( pptr() )  remain_in_buffer= epptr()-pptr();
  812.         if ( gptr() )  remain_in_buffer= egptr()-gptr();
  813.       }
  814.      
  815.      if ( (write_buff_) && !(read_buff_) )
  816.         {
  817.           remain_in_buffer= 0;
  818.         }   
  819.  
  820.      loff-= remain_in_buffer;
  821.  
  822.   } 
  823.   
  824.     int const_conv;
  825.  
  826.     #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  827.       const_conv = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  828.     #else
  829.       const_conv = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  830.     #endif
  831.       .encoding(); 
  832.  
  833.    if ( const_conv < 1 )
  834.    {
  835.      if ( (way==ios_base::beg) && (off==off_type(0)) )
  836.      {
  837.         seekpos(0);
  838.      }
  839.      else 
  840.       return pos_type(off_type(-1));
  841.    }
  842.  
  843.  
  844.   if ( write_buff_)
  845.    {  
  846.       overflow( traits::eof() );
  847.       write_buff_ =false;  
  848.    }
  849.  
  850.   
  851.   int                 w = (way == ios_base::beg) ?
  852.                            SEEK_SET : ((way == ios_base::cur) ? SEEK_CUR :
  853.                                                           SEEK_END);  
  854.   newoff = lseek(file_, loff*const_conv, w);
  855.  
  856.   setp(0,0);
  857.   setg(0,0,0);
  858.  
  859.   return newoff;
  860. }
  861.  
  862. /*
  863.  * pos_type seekpos(pos_type, ios_base::openmode)
  864.  */
  865.  
  866. template<class charT, class traits>
  867. _TYPENAME basic_filebuf<charT, traits>::pos_type
  868. basic_filebuf<charT, traits>::
  869. seekpos(pos_type sp, ios_base::openmode which)
  870. { 
  871.    if(file_ == -1)
  872.     return pos_type(off_type(-1));
  873.  
  874.    if( sp == pos_type(off_type(-1)) )
  875.     return pos_type(off_type(-1)); 
  876.  
  877.    int const_conv;
  878.  
  879.     #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
  880.       const_conv = use_facet< codecvt<charT,char,state_t> >(this->getloc())
  881.     #else
  882.       const_conv = use_facet( this->getloc(), (codecvt<charT,char,state_t>* )0)
  883.     #endif
  884.       .encoding();
  885.  
  886.    if ( const_conv > 0 )
  887.       return seekoff(off_type(sp.offset()), ios_base::beg, which);
  888.  
  889.    _TYPENAME traits::off_type end_pos = lseek(file_,0,SEEK_END);
  890.    
  891.    if ( lseek(file_, sp.pos(), SEEK_SET) == -1 )
  892.     return pos_type(off_type(-1));
  893.  
  894.    setp(0,0);
  895.    setg(0,0,0); 
  896.  
  897.    *state_beg = *state_end = sp.state();
  898.  
  899.    if ( traits::eq_int_type(underflow(),traits::eof()) && (end_pos > sp.pos()))
  900.      return pos_type(off_type(-1));
  901.  
  902.    this->gbump(sp.offset());
  903.  
  904.    return sp;   
  905. }
  906.  
  907. /*
  908.  * int sync()
  909.  *
  910.  * this synchronizes the buffers and their streams
  911.  */
  912.  
  913. template<class charT, class traits>
  914. int basic_filebuf<charT, traits>::sync()
  915. {
  916.  if ( this->which_open_mode( ) & ios_base::out )
  917. {
  918.  if ( file_ == 1 )
  919.   {
  920.     if( traits::eq_int_type(overflow(traits::eof()),traits::eof()) ) 
  921.     return -1;
  922.   }
  923.  else
  924.   { 
  925.    pos_type p_out = seekoff(0,ios_base::cur,ios_base::out);
  926.    pos_type tmp_out = lseek(file_,0,SEEK_CUR);
  927.    pos_type end_out = lseek(file_,0,SEEK_END);
  928.    lseek(file_,tmp_out,SEEK_SET);
  929.    if ( end_out > p_out )
  930.     {
  931.       if( seekpos(p_out) == pos_type(off_type(-1)))
  932.        return -1;
  933.     }
  934.    else
  935.     {
  936.        if( traits::eq_int_type(overflow(traits::eof()),traits::eof()) )
  937.         return -1;
  938.     }
  939.   }
  940. }
  941.  
  942.  if ( this->which_open_mode( ) & ios_base::in )
  943.  {
  944.   if ( file_ != 0 )
  945.    {
  946.      pos_type p_in = seekoff(0,ios_base::cur,ios_base::in);
  947.      pos_type tmp_in = lseek(file_,0,SEEK_CUR);
  948.      pos_type end_in = lseek(file_,0,SEEK_END);
  949.      lseek(file_,tmp_in,SEEK_SET);
  950.    if ( end_in > p_in )
  951.     {
  952.       if( seekpos(p_in) == pos_type(off_type(-1)))
  953.        return -1;
  954.     }
  955.    }
  956.  }
  957.  
  958.   return 0;
  959. }
  960.  
  961.  
  962. /*
  963.  * streamsize xsputn(const char_type *, streamsize)
  964.  */
  965.  
  966. template<class charT, class traits>
  967. streamsize basic_filebuf<charT, traits>::
  968. xsputn(const char_type *s, streamsize n)
  969. {
  970.   if ( !s || (n == 0) ) return 0;
  971.  
  972.   if ( n >  __rwBufferSize )
  973.   {
  974.  
  975.    if ( traits::eq_int_type(overflow( traits::eof() ),traits::eof()) )
  976.     return 0;
  977.  
  978.    char_type   *eback_s = eback();
  979.    char_type   *gptr_s  = gptr();
  980.    char_type   *egptr_s = egptr();
  981.  
  982.    char_type   *pbase_s = pbase();
  983.    char_type   *pptr_s  = pptr();
  984.    char_type   *epptr_s = epptr();
  985.  
  986.    setg(0,0,0);
  987.    setp((char_type *)s,(char_type *)(s+n));
  988.    basic_streambuf<charT, traits>::pbump(n);
  989.  
  990.    if ( traits::eq_int_type(overflow( traits::eof() ),traits::eof()) )
  991.     return 0; 
  992.   
  993.    setg(eback_s,gptr_s,egptr_s);
  994.    setp(pbase_s,epptr_s);
  995.  
  996.    pbump(pptr_s-pbase_s); 
  997.  
  998.    return n;
  999.   }
  1000.   else
  1001.   {
  1002.     int         i=0;
  1003.  
  1004.     while((i < n) && ( !traits::eq_int_type(sputc(*s++),traits::eof())))
  1005.     i++;
  1006.  
  1007.     return i;
  1008.   }
  1009.  
  1010.  }
  1011.  
  1012.  
  1013.  
  1014. /*
  1015.  *
  1016.  * class basic_ifstream : public basic_istream
  1017.  *
  1018.  */
  1019.  
  1020. /*
  1021.  * basic_ifstream()
  1022.  */
  1023.  
  1024. template<class charT, class traits>
  1025. basic_ifstream<charT, traits>::basic_ifstream()
  1026. : basic_istream<charT, traits>( )
  1027. {
  1028.    init(&fb_);
  1029. }
  1030.  
  1031. /*
  1032.  * basic_ifstream(const char *, ios_base::openmode, long)
  1033.  *
  1034.  * opens a filebuf for (most likely) reading
  1035.  */
  1036.  
  1037. template<class charT, class traits>
  1038. basic_ifstream<charT, traits>::basic_ifstream(const char *s,
  1039.                                               ios_base::openmode mode,
  1040.                                               long protection )
  1041. : basic_istream<charT, traits>( )
  1042. {
  1043.   init(&fb_);
  1044.   open(s, mode, protection);
  1045. }
  1046.  
  1047. /*
  1048.  * basic_ifstream(int fd)
  1049.  *
  1050.  * opens a filebuf for reading
  1051.  */
  1052.  
  1053. template<class charT, class traits>
  1054. basic_ifstream<charT, traits>::
  1055. basic_ifstream(int fd)
  1056. : basic_istream<charT, traits>( )
  1057. {
  1058.  
  1059.   init(&fb_);
  1060.  
  1061.   if ( !fb_.open(fd) ) 
  1062.    this->setstate(ios_base::failbit);
  1063. }
  1064.  
  1065. /*
  1066.  * basic_ifstream(int fd, char_type *buf, int len)
  1067.  *
  1068.  * opens a filebuf for reading
  1069.  */
  1070.  
  1071. template<class charT, class traits>
  1072. basic_ifstream<charT, traits>::
  1073. basic_ifstream(int fd, char_type *buf, int len)
  1074. : basic_istream<charT, traits>( )
  1075. {
  1076.  
  1077.   init(&fb_);
  1078.  
  1079.   if ( ( buf!=0 ) && ( len>0 ) )
  1080.   fb_.pubsetbuf(buf,len);
  1081.  
  1082.   if ( !fb_.open(fd) ) 
  1083.    this->setstate(ios_base::failbit);
  1084. }
  1085.  
  1086.  
  1087. /*
  1088.  * ~basic_ifstream()
  1089.  */
  1090.  
  1091. template<class charT, class traits>
  1092. basic_ifstream<charT, traits>::~basic_ifstream()
  1093. {
  1094. }
  1095.  
  1096. /*
  1097.  * basic_filebuf *rdbuf() const
  1098.  *
  1099.  * returns the streambuf associated with this stream
  1100.  */
  1101.  
  1102. template<class charT, class traits>
  1103. basic_filebuf<charT, traits> *
  1104. basic_ifstream<charT, traits>::rdbuf() const
  1105. {
  1106.   return (basic_filebuf<charT, traits> *)&fb_;
  1107. }
  1108.  
  1109. /*
  1110.  * bool is_open()
  1111.  */
  1112.  
  1113. template<class charT, class traits>
  1114. bool basic_ifstream<charT, traits>::is_open()
  1115. {
  1116.   return fb_.is_open();
  1117. }
  1118.  
  1119. /*
  1120.  * void open(const char *, ios_base::openmode, long )
  1121.  *
  1122.  * opens up a file
  1123.  */
  1124.  
  1125. template<class charT, class traits>
  1126. void basic_ifstream<charT, traits>::open(const char *s,
  1127.                                          ios_base::openmode mode,
  1128.                                          long protection )
  1129. {
  1130.   mode |= ios_base::in; 
  1131.  
  1132.   if ( !fb_.open(s, mode, protection) )  
  1133.    this->setstate(ios_base::failbit);
  1134. }
  1135.  
  1136. /* 
  1137.  * void close()
  1138.  */
  1139.  
  1140. template<class charT, class traits>
  1141. void basic_ifstream<charT, traits>::close()
  1142. {
  1143.   if(!is_open())
  1144.     return;
  1145.   
  1146.   if(!fb_.close())
  1147.     this->setstate(ios_base::failbit);
  1148. }
  1149.  
  1150.  
  1151. /*
  1152.  *
  1153.  * class basic_ofstream : public basic_ostream
  1154.  *
  1155.  */
  1156.  
  1157. /*
  1158.  * basic_ofstream()
  1159.  */
  1160.  
  1161. template<class charT, class traits>
  1162. basic_ofstream<charT, traits>::basic_ofstream()
  1163. : basic_ostream<charT, traits>( )
  1164. {
  1165.    init(&fb_);
  1166. }
  1167.  
  1168. /*
  1169.  * basic_ofstream(const char *, ios_base::openmode, long )
  1170.  */
  1171.  
  1172. template<class charT, class traits>
  1173. basic_ofstream<charT, traits>::
  1174. basic_ofstream(const char *s, ios_base::openmode mode, long protection)
  1175. : basic_ostream<charT, traits>()
  1176. {
  1177.        
  1178.   init(&fb_);
  1179.   open(s, mode, protection);
  1180. }
  1181.  
  1182. /*
  1183.  * basic_ofstream(int fd)
  1184.  *
  1185.  * opens a filebuf for writing
  1186.  */
  1187.  
  1188. template<class charT, class traits>
  1189. basic_ofstream<charT, traits>::
  1190. basic_ofstream(int fd)
  1191. : basic_ostream<charT, traits>( )
  1192. {
  1193.  
  1194.   init(&fb_);
  1195.  
  1196.   if ( !fb_.open(fd) ) 
  1197.    this->setstate(ios_base::failbit);
  1198. }
  1199.  
  1200. /*
  1201.  * basic_ofstream(int fd, char_type *buf, int len)
  1202.  *
  1203.  * opens a filebuf for writing
  1204.  */
  1205.  
  1206. template<class charT, class traits>
  1207. basic_ofstream<charT, traits>::
  1208. basic_ofstream(int fd, char_type *buf, int len)
  1209. : basic_ostream<charT, traits>( )
  1210. {
  1211.  
  1212.   init(&fb_);
  1213.  
  1214.   if ( ( buf!=0 ) && ( len>0 ) )
  1215.   fb_.pubsetbuf(buf,len);
  1216.  
  1217.   if ( !fb_.open(fd) ) 
  1218.    this->setstate(ios_base::failbit);
  1219. }
  1220.  
  1221.  
  1222. /*
  1223.  * ~basic_ofstream()
  1224.  */
  1225.  
  1226. template<class charT, class traits>
  1227. basic_ofstream<charT, traits>::~basic_ofstream()
  1228. {
  1229. }
  1230.  
  1231. /*
  1232.  * basic_filebuf *rdbuf() const
  1233.  */
  1234.  
  1235. template<class charT, class traits>
  1236. basic_filebuf<charT, traits> *
  1237. basic_ofstream<charT, traits>::rdbuf() const
  1238. {
  1239.   return (basic_filebuf<charT, traits> *)&fb_;
  1240. }
  1241.  
  1242. /*
  1243.  * bool is_open()
  1244.  */
  1245.  
  1246. template<class charT, class traits>
  1247. bool basic_ofstream<charT, traits>::is_open()
  1248. {
  1249.   return fb_.is_open();
  1250. }
  1251.  
  1252. /*
  1253.  * void open(const char *, ios_base::openmode)
  1254.  */
  1255.  
  1256. template<class charT, class traits>
  1257. void basic_ofstream<charT, traits>::open(const char *s,
  1258.                                          ios_base::openmode mode,
  1259.                                          long protection )
  1260. {
  1261.   mode |= ios_base::out;
  1262.  
  1263.   if ( !fb_.open(s, mode, protection) )
  1264.    this->setstate(ios_base::failbit);
  1265. }
  1266.  
  1267. /*
  1268.  * void close()
  1269.  */
  1270.  
  1271. template<class charT, class traits>
  1272. void basic_ofstream<charT, traits>::close()
  1273. {
  1274.   if(!is_open())
  1275.     return;
  1276.  
  1277.   if(!fb_.close())
  1278.     this->setstate(ios_base::failbit);
  1279. }
  1280.  
  1281. /*
  1282.  *
  1283.  * class basic_fstream : public basic_iostream
  1284.  *
  1285.  */
  1286.  
  1287. /*
  1288.  * basic_fstream()
  1289.  */
  1290.  
  1291. template<class charT, class traits>
  1292. basic_fstream<charT, traits>::basic_fstream()
  1293. : basic_iostream<charT, traits>( )
  1294. {
  1295.    init(&fb_);
  1296. }
  1297.  
  1298. /*
  1299.  * basic_fstream(const char *, ios_base::openmode, long)
  1300.  *
  1301.  * opens a filebuf for reading and writing
  1302.  */
  1303.  
  1304. template<class charT, class traits>
  1305. basic_fstream<charT, traits>::
  1306. basic_fstream(const char *s, ios_base::openmode mode, long protection)
  1307. : basic_iostream<charT, traits>( )
  1308. {
  1309.   init(&fb_);
  1310.   open(s, mode, protection);
  1311. }
  1312.  
  1313. /*
  1314.  * basic_fstream(int fd)
  1315.  *
  1316.  * opens a filebuf for reading and writing
  1317.  */
  1318.  
  1319. template<class charT, class traits>
  1320. basic_fstream<charT, traits>::
  1321. basic_fstream(int fd)
  1322. : basic_iostream<charT, traits>( )
  1323. {
  1324.  
  1325.   init(&fb_);
  1326.  
  1327.   if ( !fb_.open(fd) ) 
  1328.    this->setstate(ios_base::failbit);
  1329. }
  1330.  
  1331. /*
  1332.  * basic_fstream(int fd, char_type *buf, int len)
  1333.  *
  1334.  * opens a filebuf for reading and writing
  1335.  */
  1336.  
  1337. template<class charT, class traits>
  1338. basic_fstream<charT, traits>::
  1339. basic_fstream(int fd, char_type *buf, int len)
  1340. : basic_iostream<charT, traits>( )
  1341. {
  1342.  
  1343.   init(&fb_);
  1344.  
  1345.   if ( ( buf!=0 ) && ( len>0 ) )
  1346.   fb_.pubsetbuf(buf,len);
  1347.  
  1348.   if ( !fb_.open(fd) ) 
  1349.    this->setstate(ios_base::failbit);
  1350. }
  1351.  
  1352.  
  1353. /*
  1354.  * ~basic_fstream()
  1355.  */
  1356.  
  1357. template<class charT, class traits>
  1358. basic_fstream<charT, traits>::~basic_fstream()
  1359. {
  1360. }
  1361.  
  1362. /*
  1363.  * basic_filebuf *rdbuf() const
  1364.  *
  1365.  * returns the streambuf associated with this stream
  1366.  */
  1367.  
  1368. template<class charT, class traits>
  1369. basic_filebuf<charT, traits> *
  1370. basic_fstream<charT, traits>::rdbuf() const
  1371. {
  1372.   return (basic_filebuf<charT, traits> *)&fb_;
  1373. }
  1374.  
  1375. /*
  1376.  * bool is_open()
  1377.  */
  1378.  
  1379. template<class charT, class traits>
  1380. bool basic_fstream<charT, traits>::is_open()
  1381. {
  1382.   return fb_.is_open();
  1383. }
  1384.  
  1385. /*
  1386.  * void open(const char *, ios_base::openmode, long)
  1387.  *
  1388.  * opens up a file
  1389.  */
  1390.  
  1391. template<class charT, class traits>
  1392. void basic_fstream<charT, traits>::
  1393. open(const char *s, ios_base::openmode mode, long protection)
  1394. {
  1395.   mode = mode | ios_base::in | ios_base::out;
  1396.   if ( !fb_.open(s, mode, protection) ) 
  1397.    this->setstate(ios_base::failbit);
  1398. }
  1399.  
  1400. /* 
  1401.  * void close()
  1402.  */
  1403.  
  1404. template<class charT, class traits>
  1405. void basic_fstream<charT, traits>::close()
  1406. {
  1407.   if(!is_open())
  1408.     return;
  1409.   
  1410.   if(!fb_.close())
  1411.     this->setstate(ios_base::failbit);
  1412. }
  1413.  
  1414. #ifndef _RWSTD_NO_NAMESPACE
  1415. }
  1416. #endif
  1417.  
  1418. #pragma option pop
  1419. #endif /* __FSTREAM_CC */
  1420.